package com.xinjian.jianba.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class RedisConfig {
	private static final Logger LOGGER = LoggerFactory.getLogger(RedisConfig.class);

	@Value("${spring.redis.host}")
	private String host; // Redis服务器地址
	@Value("${spring.redis.port}")
	private int port; // Redis服务器连接端口
	@Value("${spring.redis.password}")
	private String password; // Redis服务器连接密码（默认为空）
	@Value("${spring.redis.timeout}")
	private int timeout; // 连接超时时间（毫秒）
	@Value("${spring.redis.database}")
	private int database; // 连接超时时间（毫秒）
	@Value("${spring.redis.pool.max-active}")
	private int maxTotal; // 连接池最大连接数（使用负值表示没有限制）
	@Value("${spring.redis.pool.max-wait}")
	private int maxWaitMillis; // 连接池最大阻塞等待时间（使用负值表示没有限制）
	@Value("${spring.redis.pool.max-idle}")
	private int maxIdle; // 连接池中的最大空闲连接
	@Value("${spring.redis.pool.min-idle}")
	private int minIdle; // 连接池中的最小空闲连接

	@Bean(name = "redisTemplate")
	public RedisTemplate<?, ?> redisTemplate(RedisConnectionFactory factory) {
		RedisTemplate<?, ?> redisTemplate = new RedisTemplate<>();
		redisTemplate.setConnectionFactory(factory);
		// key序列化方式;但是如果方法上有Long等非String类型的话，会报类型转换错误；
		RedisSerializer<String> redisSerializer = new StringRedisSerializer();// Long类型不可以会出现异常信息;
		redisTemplate.setKeySerializer(redisSerializer);
		redisTemplate.setHashKeySerializer(redisSerializer);

		redisTemplate.setKeySerializer(new StringRedisSerializer());
		redisTemplate.setValueSerializer(new RedisObjectSerializer());

		// JdkSerializationRedisSerializer序列化方式;
		JdkSerializationRedisSerializer jdkRedisSerializer = new JdkSerializationRedisSerializer();
		// redisTemplate.setValueSerializer(jdkRedisSerializer);
		redisTemplate.setValueSerializer(new RedisObjectSerializer());
		redisTemplate.setHashValueSerializer(jdkRedisSerializer);
		// redisTemplate.afterPropertiesSet();
		return redisTemplate;
	}

	/**
	 * 配置JedisPoolConfig
	 * 
	 * @return JedisPoolConfig实体
	 */
	@Bean(name = "jedisPoolConfig")
	public JedisPoolConfig jedisPoolConfig() {
		LOGGER.info("-------初始化JedisPoolConfig---------------");
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		jedisPoolConfig.setMaxTotal(maxTotal); // 连接池最大连接数（使用负值表示没有限制）
		jedisPoolConfig.setMaxWaitMillis(maxWaitMillis); // 连接池最大阻塞等待时间（使用负值表示没有限制）
		jedisPoolConfig.setMaxIdle(maxIdle); // 连接池中的最大空闲连接
		jedisPoolConfig.setMinIdle(minIdle); // 连接池中的最小空闲连接
		jedisPoolConfig.setTestOnBorrow(true);
		jedisPoolConfig.setTestOnCreate(true);
		jedisPoolConfig.setTestWhileIdle(true);
		return jedisPoolConfig;
	}

	/**
	 * 实例化 RedisConnectionFactory 对象
	 * 
	 * @param poolConfig
	 * @return
	 */
	@Bean(name = "jedisConnectionFactory")
	public RedisConnectionFactory jedisConnectionFactory(
			@Qualifier(value = "jedisPoolConfig") JedisPoolConfig poolConfig) {
		LOGGER.info("------初始化RedisConnectionFactory-------");
		JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(poolConfig);
		jedisConnectionFactory.setHostName(host);
		jedisConnectionFactory.setPort(port);
		jedisConnectionFactory.setDatabase(database);
		jedisConnectionFactory.setPassword(password);
		jedisConnectionFactory.setTimeout(timeout);
		return jedisConnectionFactory;
	}

}